/**
 * 
 */
package com.gosophia.govDoc.weboffice.service;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.UUID;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;
import org.springframework.util.Assert;

import com.gosophia.commons.exception.BusinessException;
import com.gosophia.contentRepo.ContentConstants;
import com.gosophia.contentRepo.domain.File;
import com.gosophia.contentRepo.domain.Resource;
import com.gosophia.contentRepo.service.FileSystemService;
import com.gosophia.govDoc.ws.DocumentTurningWebService;
import com.gosophia.govDoc.ws.TransientDocumentWebService;

/**
 * 功能：
 * 
 * @author zhangdongsheng
 * @since 2010-11-29 Copyright (c) 2010 Gosophia corporation All Rights Reserved
 */

public class WebOfficeServer {
    
    private static String DEFAULT_FILE_NAME ="unTurningFile";//默认文档名称
	// private String missionId;
	// private String jobId;
    
    private String mRecordId;//文档的唯一标识，这里使用UUID
    private String mFilePath;// 文件地址，文件路径存放规则：/用户名/UUID，参见generateFilePath(String userName)
    private String mFileName;// 文件名称,文件名生成规则：如果传入的文件名称不为空格（""）则使用此文件名，如果为空默认为"unTurningFile" ，参见generateFileName(String fileName)
	private int mFileSize;//文件大小
	private byte[] mFileBody;// 文件主体
	private String mFileType ="text/plain";// 文件类型
	private String mFileDate;// 文件日期
//	private String mFileID;  // 文件id
	private String mFileDescript;// 文件描述
	private String mFileTag;// 文件标签，类似关键字的作用
	private String mFileVersion;// 文件version

	private String mTemplateId;// 模板id
	private String mTemplate;// 模板
	private String mDateTime;// 日期
	private String mOption;// 选项
	private String mMarkName;// 签名
	private String mPassword;// 密码
	private String mMarkList;// 书签列表
	private String mBookmark;// 书签
	private String mDescript;// 描述
	private String mHostName;// 主机名称
	private String mMarkGuid;
	private String mCommand;
	private String mContent;
	private String mHtmlName;
	private String mDirectory;// 目录

	
	//private String mJobId;      // 待办任务编号
	private String mUserName;   // 用户名称
	//private String mUserInfoId; // 用户信息id
	
	private int mColumns;// 行
	private int mCells;// 单元格
	private String mMyDefine1;// 自定义
	private String mLocalFile;// 本地文件
	private String mRemoteFile;// 远程文件
	private String mLabelName;// 标签名称
	private String mImageName;// 图片名称
	private String mTableContent;// 表格内容
	private String Sql;// sql语句

	private String mSaveType;
	
	String redirectUrl;
	String redirectBase;

	String vMarkName;
	String vPassWord;
	// 打印控制
	private String mOfficePrints;
	private int mCopies;
	// 自定义信息传递
	private String mInfo;
	private DBstep.iMsgServer2000 MsgObj;

	private final Logger logger = Logger.getLogger(this.getClass());

	// private CmsServiceImpl cmsService;

	private FileSystemService fileSystemService;

	// private GovDocWebService govDocWebService;
	private DocumentTurningWebService documentTurningWebService;

	private TransientDocumentWebService transientDocumentWebService;

	// 格式化日期时间
	public String FormatDate(String DateValue, String DateType) {
		String Result;
		SimpleDateFormat formatter = new SimpleDateFormat(DateType);
		try {
			Date mDateTime = formatter.parse(DateValue);
			Result = formatter.format(mDateTime);
		} catch (Exception ex) {
			Result = ex.getMessage();
		}
		if (Result.equalsIgnoreCase("1900-01-01")) {
			Result = "";
		}
		return Result;
	}

	
	
	/*****************************文件路径和文件名生成工具方法*************************************************************/
     private String generateFileName(String fileName){//如果传入的文件名称为空格，则返回默认文件名称
       if("".equals(fileName)||fileName==null){
           return DEFAULT_FILE_NAME;
       }
       return fileName;
     }
     
     private String obatainFilePath(String userName,String recordId){
        Assert.hasText(userName,"when load file  userName must not be null or must contain at least one non-whitespace character ");
        if(recordId==null||"".equals(recordId)){
            String filePath ="/"+userName;
            recordId= UUID.randomUUID().toString();
            filePath= filePath+"/"+recordId;
           return filePath;//recordId为null，生成一个新的文件路径：/userName/uuid
        }
        return  recordId;//"/"+userName+"/"+recordId;
     }
	
	/*********************************************************************************************************************/
	
	
	
	private void readInWebOffice(){
	    
	    logger.info("服务器读取webOfficePlugin 信息");
        mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档记录编号
        mUserName = MsgObj.GetMsgByName("USERNAME");     // 取得保存用户名称
        
        
        mFilePath =obatainFilePath(mUserName,mRecordId);
        mFileBody = MsgObj.MsgFileBody(); // 取得文档内容
        mFileSize = MsgObj.MsgFileSize(); // 取得文档大小
        mFileName =generateFileName(MsgObj.GetMsgByName("FILENAME"));
        mFileVersion = MsgObj.GetMsgByName("FILEVERSION");
        logger.info("读入文档路径=>"+mRecordId+"  USERNAME=>"+mUserName+"  FILESIZE=>"+mFileSize+" mfileVersion :"+mFileVersion);
        //MsgObj.MsgFileClear();
        //MsgObj.MsgTextClear();
	}
     
	/**
	 * writeAll = false  只写出文件操作是否成功信息
	 * writeAll = true   写出文档全部信息 
	 * @throws IOException 
	 * */
	private boolean writeOutWebOffice(File file ,boolean writeAll) throws IOException{//writeAll=false
         boolean isSuccess = false;
        if(file!=null){//操作成功
           mRecordId = mFilePath;//mFilePath.substring(mFilePath.lastIndexOf("/")+1);
           MsgObj.SetMsgByName("STATUS", "操作成功!"); // 设置状态信息
           MsgObj.SetMsgByName("RECORDID", mRecordId);
           MsgObj.SetMsgByName("FILEVERSION", mFileVersion);
           logger.debug("写出文档路径：=>"+mRecordId +" 文档版本：=>"+ mFileVersion);
           //MsgObj.SetMsgByName("FILEPATH", file.getPath());
           if(writeAll){
                MsgObj.MsgFileBody(file.getResource().getByteData());//写出文档内容
                logger.debug("写出文件内容");
            }
            MsgObj.MsgError("");//清除错误信息
            isSuccess =true;
        }else{
            MsgObj.MsgError("操作失败!");
            MsgObj.MsgTextClear();
        }
      return    isSuccess;
	}
	
     
	
	// ==============================↓文档 和 模板
	// 代码【开始】↓==============================
	 //根据用户名和mRecordId加载文档
	private boolean LoadFile() throws NumberFormatException, BusinessException,
			IOException {
		boolean mResult = false;
		
		readInWebOffice();
		File file=null;
		if(mFileVersion!=null&&
		        !"".equals(mFileVersion)&&
		        !"jcr:rootVersion".equalsIgnoreCase(mFileVersion )&&
		        !"LATEST_VERSION".equalsIgnoreCase(mFileVersion)
		        ){
		    file = fileSystemService.getFileByVersion(ContentConstants.FILE_ROOT_PATH+mFilePath, mFileVersion) ;//加载文档
		}else{//获取最新版本
		     file = (File) fileSystemService.findByPath(ContentConstants.FILE_ROOT_PATH+mFilePath);//加载文档
		}
		logger.debug("load File ，then write out file");
		mResult =writeOutWebOffice(file,true);
		
		return (mResult);
	}

	// 保存文档 
	private boolean SaveFile() throws BusinessException, IOException {
		logger.info("save file start");
		boolean mResult = false;
		 File file=null;
		 
		 readInWebOffice();
		  
		 if("".equals(mRecordId)||mRecordId==null){//记录不存在
		      file= saveDocument();//保存文档
		  }else{
		      file= updataDocument();//更新文档
		  }
		  mResult =writeOutWebOffice(file,false);
		  
		  return (mResult);
	}
	
	private File saveDocument(){
	    logger.info("文档创建开始 ");
        File file = new File();

        Calendar creationDate = Calendar.getInstance();
        
        Resource resource = new Resource();
        resource.setLastModified(creationDate);
        resource.setMimeType(mFileType);
        resource.setData(new ByteArrayInputStream(mFileBody));

        file.setResource(resource);
        file.setName(mFileName);
        file.setOwner(mUserName);
        file.setCreationDate(creationDate);
        file.setPath(mFilePath);

        try {
            logger.debug("save file first start");
            fileSystemService.save(file);
            logger.debug("save file first succ :=>" +mFileVersion);
            mFileVersion=fileSystemService.getLastedVersionName(file.getPath());
            if("jcr:rootVersion".equalsIgnoreCase(mFileVersion)){
                logger.debug("verison 为jcr:rootVersion ,越过此版本，再次保存");
                File file2 = new File(); 
                Calendar creationDate2 = Calendar.getInstance();
                
                Resource resource2 = new Resource();
                resource2.setLastModified(creationDate2);
                resource2.setMimeType(mFileType);
                resource2.setData(new ByteArrayInputStream(mFileBody));

                file2.setResource(resource2);
                file2.setName(mFileName);
                file2.setOwner(mUserName);
                file2.setCreationDate(creationDate2);
                file2.setPath(mFilePath);
                fileSystemService.save(file2);//越过jcr:rootVersion 版本
                mFileVersion=fileSystemService.getLastedVersionName(mFilePath);
                logger.debug("verison 从jcr:rootVersion升级为："+mFileVersion);
            }
        } catch (Exception e) {
           logger.error("保存文档失败", e);
        }
        logger.info("保存内容管理成功：path=>" + mFilePath);
	    return file;
	}
	private File updataDocument(){
	    logger.info("文档更新开始时的版本："+ mFileVersion);
	    mFileVersion=fileSystemService.getLastedVersionName(mFilePath);
	    Calendar creationDate = Calendar.getInstance();
	    //根据文档路径 获取文档
	    File file = (File) fileSystemService.findByPath(mFilePath);
	    Resource resource = new Resource();
        resource.setLastModified(creationDate);
        resource.setMimeType(mFileType);
        resource.setData(new ByteArrayInputStream(mFileBody));
	    file.setResource(resource);
    
        try {
            fileSystemService.update(file);
            mFileVersion=fileSystemService.getLastedVersionName(mFilePath);
        } catch (Exception e) {
           logger.error("保存文档失败", e);
        }
        logger.info("更新内容管理成功：path=>" + mFilePath+"  mFileVersion=>" + mFileVersion);
	    return file;
	}
	
	
	
	
//	private boolean saveInProcessDocument() throws BusinessException {
//		Boolean mResult = false;
//		File file = (File) fileSystemService.findByPath(mFileID);
//		
//		Calendar creationDate = Calendar.getInstance();
////		file.setCreationDate(creationDate);
////		file.setDescription(mFileDescript);
////		file.setName(mFileName);
////		file.setTags(mFileTag.split(","));
////		file.setOwner(mUserName);
//		// file.setPath(mFilePath);
//
//		file.getResource().setLastModified(creationDate);
////		file.getResource().setMimeType(mFileType);
//		file.getResource().setData(new ByteArrayInputStream(mFileBody));
//
//		try {
//			fileSystemService.save(file);
//			
//			MsgObj.SetMsgByName("STATUS", "保存成功!"); // 设置状态信息
//			MsgObj.MsgError(""); // 清除错误信息
//			logger.debug("暂存公文更新成功，#mRecordId=>" + mRecordID);
//			mResult = true;
//		} catch (Exception e) {
//			e.printStackTrace();
//			logger.debug("公文记录更新失败，#mRecordId=>" + mRecordID);
//			MsgObj.MsgError("保存失败!"); // 设置错误信息
//		}
//		
//		return mResult;
//	}

//	private Boolean saveTransientDocument() throws BusinessException {
//		Boolean mResult = false;
//		Long userId = Long.valueOf(mUserInfoId);
//		
////		TransientDocumentDTO transientDocumentDTO 
////		= transientDocumentWebService.findTranDocByCreatorAndJobId(userId, null);
//		
////		if (transientDocumentDTO == null){
////			throw new BusinessException("没有找到用户："+MsgObj.GetMsgByName("USERACCOUNTID")
////					+" 的暂存记录！","JC2_GOVDOC_B_01");
////		}
//		
////		if (transientDocumentDTO.getPath() == null 
////				|| transientDocumentDTO.getPath().isEmpty()
////				|| transientDocumentDTO.getDocumentVersion() == null 
////				|| transientDocumentDTO.getDocumentVersion().isEmpty()) {
//
//			logger.info("暂存公文尚未被创建，创建开始 ");
//
//			File file = new File();
//			Calendar creationDate = Calendar.getInstance();
//			file.setCreationDate(creationDate);
//			file.setDescription(mFileDescript);
//			file.setName(mFileID.substring(mFileID.lastIndexOf("/")+1));
//			file.setTags(mFileTag.split(","));
//			file.setOwner(mUserName);
//			file.setPath(mFileID);
//
//			Resource resource = new Resource();
//			resource.setLastModified(creationDate);
//			resource.setMimeType(mFileType);
//			resource.setData(new ByteArrayInputStream(mFileBody));
//
//			file.setResource(resource);
//			try {
//				fileSystemService.save(file);
//			} catch (Exception e) {
//				e.printStackTrace();
//			}
//
//			mFileID = file.getPath();
//			logger.info("保存内容管理成功：path=>" + mFileID);
//
//			String documentVersion = fileSystemService.getLastedVersionName(mFileID);
//
//			transientDocumentDTO.setPath(mFileID);
//			transientDocumentDTO.setDocumentVersion(documentVersion);
//
//			logger.info("开始暂存公文");
//			transientDocumentWebService
//					.savaOrUpdateTransientDocument(transientDocumentDTO);
//
//			mRecordID = Long.toString(transientDocumentDTO.gettDocId());
//			logger.info("暂存公文成功，返回暂存公文id" + mRecordID);
//
//			MsgObj.SetMsgByName("RECORDID", mRecordID);
//			MsgObj.SetMsgByName("FILEID", mFileID);
//			mResult = true;
//			MsgObj.MsgFileClear();
//		} else {
//			logger.info("公文记录已经存在：#mRecordID" + mRecordID);
//			File file = (File) fileSystemService.findByPath(transientDocumentDTO.getPath());
//			mFileID = file.getPath();
//			Calendar creationDate = Calendar.getInstance();
////			file.setCreationDate(creationDate);
////			file.setDescription(mFileDescript);
////			file.setName(mFileName);
////			file.setTags(mFileTag.split(","));
////			file.setOwner(mUserName);
//			// file.setPath(mFilePath);
//
//			file.getResource().setLastModified(creationDate);
//			file.getResource().setMimeType(mFileType);
//			file.getResource().setData(new ByteArrayInputStream(mFileBody));
//
//			try {
//				fileSystemService.save(file);
//				String documentVersion = fileSystemService.getLastedVersionName(file.getPath());
//				transientDocumentDTO.setPath(mFileID);
//				transientDocumentDTO.setDocumentVersion(documentVersion);
//
//				logger.info("开始暂存公文");
//				transientDocumentWebService
//						.savaOrUpdateTransientDocument(transientDocumentDTO);
//
//				MsgObj.SetMsgByName("STATUS", "保存成功!"); // 设置状态信息
//				MsgObj.MsgError(""); // 清除错误信息
//				logger.debug("暂存公文更新成功，#mRecordId=>" + mRecordID);
//				mResult = true;
//			} catch (Exception e) {
//				e.printStackTrace();
//				logger.debug("公文记录更新失败，#mRecordId=>" + mRecordID);
//				MsgObj.MsgError("保存失败!"); // 设置错误信息
//			}
//			MsgObj.MsgFileClear();
//		}
//		
//		return mResult;
//	}

	// 调出模板文档，将模板文档内容保存在mFileBody里，以便进行打包
	private boolean LoadTemplate() {
		boolean mResult = false;
		mTemplate = MsgObj.GetMsgByName("TEMPLATE");
		mTemplateId = MsgObj.GetMsgByName("templateId");
		mCommand = MsgObj.GetMsgByName("COMMAND"); // 取得客户端定义的变量COMMAND值

		//          
		// if (mCommand.equalsIgnoreCase("INSERTFILE")) {
		// if (MsgObj.MsgFileLoad(mFilePath + "\\Document\\" + mTemplate)) {
		// //从服务器文件夹中调入模板文档
		// MsgObj.SetMsgByName("STATUS", "打开模板成功!"); //设置状态信息
		// MsgObj.MsgError(""); //清除错误信息
		// }
		// else {
		// MsgObj.MsgError("打开模板失败!"); //设置错误信息
		// }
		// }
		// else {
		//              
		// MsgObj.MsgTextClear(); //清除文本信息
		// MsgObj.MsgFileBody(mFileBody); //将文件信息打包
		// MsgObj.SetMsgByName("STATUS", "打开模板成功!"); //设置状态信息
		// MsgObj.MsgError(""); //清除错误信息
		//             
		//             
		//                         
		//         
		// }
		return (mResult);
	}

	public FileSystemService getFileSystemService() {
		return fileSystemService;
	}

	public void setFileSystemService(FileSystemService fileSystemService) {
		this.fileSystemService = fileSystemService;
	}

	public DocumentTurningWebService getDocumentTurningWebService() {
		return documentTurningWebService;
	}

	public void setDocumentTurningWebService(
			DocumentTurningWebService documentTurningWebService) {
		this.documentTurningWebService = documentTurningWebService;
	}

	public TransientDocumentWebService getTransientDocumentWebService() {
		return transientDocumentWebService;
	}

	public void setTransientDocumentWebService(
			TransientDocumentWebService transientDocumentWebService) {
		this.transientDocumentWebService = transientDocumentWebService;
	}

	// 保存模板文档，如果模板文档存在，则覆盖，不存在，则添加
	private boolean SaveTemplate() {
		boolean mResult = false;
		mTemplate = MsgObj.GetMsgByName("TEMPLATE"); // 取得文档编号
		mFileName = MsgObj.GetMsgByName("FILENAME"); // 取得文档名称
		mFileType = MsgObj.GetMsgByName("FILETYPE"); // 取得文档类型
//		mUserName = mUserName; // 取得保存用户名称
		mUserName = MsgObj.GetMsgByName("USERNAME");// 取得保存用户名称
		mDescript = "通用模板"; // 版本说明
		mFileSize = MsgObj.MsgFileSize(); // 取得文档大小
		mFileBody = MsgObj.MsgFileBody(); // 取得文档内容
		MsgObj.MsgTextClear();
		if (SaveTemplate()) { // 保存模板文档内容
			MsgObj.SetMsgByName("STATUS", "保存模板成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("保存模板失败!"); // 设置错误信息
		}
		MsgObj.MsgFileClear();
		return (mResult);
	}

	// ==============================↑文档、模板管理代码【结束】↑==============================

	// ==============================↓版本管理代码【开始】↓==============================
	// 列出所有版本信息
	private boolean ListVersion() {
		boolean mResult = false;
		mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档编号
		MsgObj.MsgTextClear();
		if (ListVersion()) { // 生成版本列表
			//MsgObj.SetMsgByName("FILEID", mFileID); // 将文档号列表打包
			MsgObj.SetMsgByName("DATETIME", mDateTime); // 将日期时间列表打包
			MsgObj.SetMsgByName("USERNAME", mUserName); // 将用户名列表打包
			MsgObj.SetMsgByName("DESCRIPT", mDescript); // 将说明信息列表打包
			MsgObj.SetMsgByName("STATUS", "版本列表成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("版本列表失败!"); // 设置错误信息
		}
		return (mResult);
	}

	// 调入选中版本，通过文件号调用mFileID,并把文件放入mFileBody里，以便进行打包
	private boolean LoadVersion(String mFileID) {
		boolean mResult = false;
		mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档编号
		mFileID = MsgObj.GetMsgByName("FILEID"); // 取得版本文档号
		MsgObj.MsgTextClear();
		if (LoadVersion(mFileID)) { // 调入该版本文档
			MsgObj.MsgFileBody(mFileBody); // 将文档信息打包
			MsgObj.SetMsgByName("STATUS", "打开版本成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("打开版本失败!"); // 设置错误信息
		}
		return (mResult);
	}

	// 保存版本，将该版本文件存盘，并将说明信息也保存起来
	private boolean SaveVersion() {
		boolean mResult = false;
		mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档编号
		//mFileID = MsgObj.GetMsgByName("FILEID"); // 取得版本文档号
													// 如:WebSaveVersionByFileID，则FileID值存在
		mFileName = MsgObj.GetMsgByName("FILENAME"); // 取得文档名称
		mFileType = MsgObj.GetMsgByName("FILETYPE"); // 取得文档类型
//		mUserName = mUserName; // 取得保存用户名称
		mUserName = MsgObj.GetMsgByName("USERNAME");// 取得保存用户名称
		mDescript = MsgObj.GetMsgByName("DESCRIPT"); // 取得说明信息
		mFileSize = MsgObj.MsgFileSize(); // 取得文档大小
		// 取得文档时间
		mFileBody = MsgObj.MsgFileBody(); // 取得文档内容
		MsgObj.MsgTextClear();
		if (SaveVersion()) { // 保存版本文档
			MsgObj.SetMsgByName("STATUS", "保存版本成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("保存版本失败!"); // 设置错误信息
		}
		MsgObj.MsgFileClear();
		return (mResult);
	}

	// ==============================↑版本管理代码【结束】↑==============================

	// ==============================↓标签管理代码【开始】↓==============================
	// 取得书签列表
	private boolean ListBookmarks() {
		boolean mResult = false;
		MsgObj.MsgTextClear(); // 清除文本信息
//		if (cmsService.listAllGovTemplates().size() != 0) {
//			MsgObj.SetMsgByName("BOOKMARK", mBookmark); // 将用户名列表打包
//			MsgObj.SetMsgByName("DESCRIPT", mDescript); // 将说明信息列表打包
//			MsgObj.MsgError(""); // 清除错误信息
//		} else {
//			MsgObj.MsgError("调入标签失败!"); // 设置错误信息
//		}
		return (mResult);
	}

	// 装入书签
	private boolean LoadBookMarks() {
		boolean mResult = false;

		return (mResult);
	}

	// 保存书签
	private boolean SaveBookMarks() {
		boolean mResult = false;
		mTemplate = MsgObj.GetMsgByName("TEMPLATE"); // 取得模板编号
		if (SaveBookMarks()) {
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("保存标签信息失败!"); // 设置错误信息
		}
		MsgObj.MsgTextClear();
		return (mResult);
	}

	// ==============================↑标签管理代码【结束】↑==============================

	// ==============================↓签章管理代码【开始】↓==============================
	// 取得签名列表
	private boolean LoadMarkList() {
		boolean mResult = false;
		MsgObj.MsgTextClear(); // 清除文本信息
		if (LoadMarkList()) {
			MsgObj.SetMsgByName("MARKLIST", mMarkList); // 显示签章列表
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("创建印章列表失败!"); // 设置错误信息
		}
		return (mResult);
	}

	// 调入签名纪录
	private boolean LoadMarkImage(String vMarkName, String vPassWord) {

		boolean mResult = false;
		mMarkName = MsgObj.GetMsgByName("IMAGENAME"); // 取得签名名称
		mUserName = MsgObj.GetMsgByName("USERNAME"); // 取得用户名称
		mPassword = MsgObj.GetMsgByName("PASSWORD"); // 取得用户密码
		MsgObj.MsgTextClear(); // 清除文本信息
		if (LoadMarkImage(mMarkName, mPassword)) { // 调入签名信息
			MsgObj.SetMsgByName("IMAGETYPE", mFileType); // 设置签名类型
			MsgObj.MsgFileBody(mFileBody); // 将签名信息打包
			MsgObj.SetMsgByName("POSITION", "Manager"); // 插入位置 在文档中标签"Manager"
			MsgObj.SetMsgByName("ZORDER", "5"); // 4:在文字上方 5:在文字下方
			MsgObj.SetMsgByName("STATUS", "打开成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("签名或密码错误!"); // 设置错误信息
		}
		return (mResult);
	}

	// 保存签名
	private boolean SaveSignature() {
		boolean mResult = false;
		mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档编号
		mFileName = MsgObj.GetMsgByName("FILENAME"); // 取得文件名称
		mMarkName = MsgObj.GetMsgByName("MARKNAME"); // 取得签名名称
		mUserName = MsgObj.GetMsgByName("USERNAME"); // 取得用户名称
		mDateTime = MsgObj.GetMsgByName("DATETIME"); // 取得签名时间
		// mHostName = request.getRemoteAddr(); //取得用户IP
		mMarkGuid = MsgObj.GetMsgByName("MARKGUID"); // 取得唯一编号
		MsgObj.MsgTextClear(); // 清除文本信息
		if (SaveSignature()) { // 保存签章
			MsgObj.SetMsgByName("STATUS", "保存印章成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("保存印章失败!"); // 设置错误信息
		}
		return (mResult);
	}

	// 列出所有签名
	private boolean LoadSignature() {
		boolean mResult = false;
		mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档编号
		MsgObj.MsgTextClear(); // 清除文本信息
		if (LoadSignature()) { // 调出签章
			MsgObj.SetMsgByName("MARKNAME", mMarkName); // 将签名名称列表打包
			MsgObj.SetMsgByName("USERNAME", mUserName); // 将用户名列表打包
			MsgObj.SetMsgByName("DATETIME", mDateTime); // 将时间列表打包
			MsgObj.SetMsgByName("HOSTNAME", mHostName); // 将盖章IP地址列表打包
			MsgObj.SetMsgByName("MARKGUID", mMarkGuid); // 将唯一编号列表打包
			MsgObj.SetMsgByName("STATUS", "调入印章成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("调入印章失败!"); // 设置错误信息
		}
		return (mResult);
	}

	// ==============================↑签章管理代码【结束】↑==============================

	// ==============================↓扩展功能代码【开始】↓==============================
	// 调出所对应的文本
	private boolean LoadContent() {
		boolean mResult = false;
		// 打开数据库
		// 根据 mRecordId 或 mFileName 等信息
		// 提取文本信息付给mContent即可。
		// 本演示假设取得的文本信息如下：
		mContent = "";
		mContent += "本文的纪录号：" + mRecordId + "\n";
		mContent += "本文的文件名：" + mFileName + "\n";
		mContent += "    这个部分请自己加入，和你们的数据库结合起来就可以了\n";
		mResult = true;
		return (mResult);
	}

	// 保存所对应的文本
	private boolean SaveContent() {
		boolean mResult = false;
		// 打开数据库
		// 根据 mRecordId 或 mFileName 等信息
		// 插入文本信息 mContent里的文本到数据库中即可。
		mResult = true;
		return (mResult);
	}

	// 增加行并填充表格内容
	private boolean GetWordTable() {
		int i, n;
		String strI, strN;
		boolean mResult;
		mColumns = 3;
		mCells = 8;
		MsgObj.MsgTextClear();
		MsgObj.SetMsgByName("COLUMNS", String.valueOf(mColumns)); // 设置表格行
		MsgObj.SetMsgByName("CELLS", String.valueOf(mCells)); // 设置表格列
		// 该部分内容可以从数据库中读取
		try {
			for (i = 1; i <= mColumns; i++) {
				strI = String.valueOf(i);
				for (n = 1; n <= mCells; n++) {
					// MsgObj.SetMsgByName(String.valueOf(i) +
					// String.valueOf(n), "内容" + DbaObj.GetDateTime());
				}
			}
			mResult = true;
		} catch (Exception e) {
			System.out.println(e.toString());
			mResult = false;
		}
		return (mResult);
	}

	// 更新打印份数
	private boolean UpdataCopies(int mLeftCopies) {
		boolean mResult = true;
		// 该函数可以把打印减少的次数记录到数据库
		// 根据自己的系统进行扩展该功能
		return mResult;
	}

	// ==============================↑扩展功能代码【结束】↑==============================

	// ==============================↓接收流、写回流代码【开始】↓==============================
	// 取得客户端发来的数据包
	private byte[] ReadPackage(HttpServletRequest request) {
		byte mStream[] = null;
		int totalRead = 0;
		int readBytes = 0;
		int totalBytes = 0;
		try {
			totalBytes = request.getContentLength();
			mStream = new byte[totalBytes];
			while (totalRead < totalBytes) {
				request.getInputStream();
				readBytes = request.getInputStream().read(mStream, totalRead,
						totalBytes - totalRead);
				totalRead += readBytes;
				continue;
			}
		} catch (Exception e) {
			System.out.println(e.toString());
		}
		return (mStream);
	}

	// 发送处理后的数据包
	private void SendPackage(HttpServletResponse response) {
		try {
			ServletOutputStream OutBinarry = response.getOutputStream();
			OutBinarry.write(MsgObj.MsgVariant());
			OutBinarry.flush();
			OutBinarry.close();
		} catch (IOException e) {
			System.out.println(e.toString());
		}
	}

	// ==============================↑接收流、写回流代码【结束】↑==============================

	public void ExecuteRun(HttpServletRequest request,
			HttpServletResponse response) {

		// DbaObj = new DBstep.iDBManager2000(); //创建数据库对象
		MsgObj = new DBstep.iMsgServer2000(); // 创建信息包对象

		mOption = "";
		mRecordId = MsgObj.GetMsgByName("RECORDID");//TODO:此处MsgObj还未加载请求里的数据
		mTemplate = "";

		mFileName = "";
		mFileBody = null;
		mFileType = "";
		mFileSize = 0;
		mFileDescript = "";
		mFileTag = "";// 文件标签

		mDateTime = "";
		mMarkName = "";
		mPassword = "";
		mMarkList = "";
		mBookmark = "";
		mMarkGuid = "";
		mDescript = "";
		mCommand = "";
		mContent = "";
		mLabelName = "";
		mImageName = "";
		mTableContent = "";
		mMyDefine1 = "";
		mOfficePrints = "0";
		mFilePath = request.getSession().getServletContext().getRealPath(""); // 取得服务器路径

		String mHttpUrlName = request.getRequestURI();
		String mScriptName = request.getServletPath();
		redirectBase = "http://"
				+ request.getServerName()
				+ ":"
				+ request.getServerPort()
				+ mHttpUrlName.substring(0, mHttpUrlName
						.lastIndexOf(mScriptName)) + "/";

		System.out.println("ReadPackage");

		try {
			if (request.getMethod().equalsIgnoreCase("POST")) {
				MsgObj.Load(request); // 8.1.0.2版后台类新增解析接口，可支持UTF-8编码自适应功能（加载请求里的数据，把属性封装到对象中）

				if (MsgObj.GetMsgByName("DBSTEP").equalsIgnoreCase("DBSTEP")) { // 判断是否是合法的信息包，或者数据包信息是否完整
					mOption = MsgObj.GetMsgByName("OPTION"); // 取得操作信息
					mUserName = MsgObj.GetMsgByName("USERNAME"); // 取得系统用户
					System.out.println("OPTION:" + mOption);
					WebofficeOptions wOption = WebofficeOptions
							.valueOf(mOption);

					// 处理各种请求
					handler(wOption);

				} else {
					MsgObj.MsgError("客户端发送数据包错误!");
					MsgObj.MsgTextClear();
					MsgObj.MsgFileClear();
				}

			} else {
				MsgObj.MsgError("请使用Post方法");
				MsgObj.MsgTextClear();
				MsgObj.MsgFileClear();
			}

			System.out.println("SendPackage");
			System.out.println("");

			MsgObj.Send(response); // 8.1.0.2新版后台类新增的功能接口，返回信息包数据
			System.out.println("end mark !!!");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * @param mOption2
	 * @throws BusinessException 
	 * @throws IOException 
	 * @throws NumberFormatException 
	 */
	private void handler(WebofficeOptions wOption) throws BusinessException, NumberFormatException, IOException {
		switch (wOption) {
		case LOADFILE:
			LoadFile();
			break; // 加载文件
		case SAVEFILE:
			SaveFile();
			break;// 保存文件
		case LOADTEMPLATE:
			LoadTemplate();
			break;// 加载模板
		case SAVETEMPLATE:
			SaveTemplate();
			break;// 保存模板
		case LISTVERSION:
			ListVersion();
			break;// 列出所有版本
		case LOADVERSION:
			LoadVersion(mRecordId);
			break;// 加载版本
		case SAVEVERSION:
			SaveVersion();
			break;// 保存版本
		case LOADBOOKMARKS:
			LoadBookMarks();
			break;// 加载书签
		case SAVEBOOKMARKS:
			SaveBookMarks();
			break;// 保存书签
		case LISTBOOKMARKS:
			ListBookmarks();
			break;// 列出书签
		case LOADMARKLIST:
			LoadMarkList();
			break;// 加载签名列表

		case LOADMARKIMAGE:
			LoadMarkImage(vMarkName, vPassWord);
			break;// 加载签名图片
		case SAVESIGNATURE:
			SaveSignature();
			break;// 保存签名
		case LOADSIGNATURE:
			LoadSignature();
			break;// 加载签名
		case SAVEPDF:
			savePdf();
			break;// 保存pdf
		case SAVEASHTML:
			saveAsHtml();
			break;// 保存为html
		case SAVEIMAGE:
			saveImage();
			break;// 保存图片
		case SAVEASPAGE:
			saveAsPage();
			break;// 保存全文批注格式的文件
		case INSERTFILE:
			insertFile();
			break;// 插入文件
		case UPDATEFILE:
			updateFile();
			break;// 更新文件
		case INSERTIMAGE:
			insertImage();
			break;// 插入图片
		case PUTFILE:
			putFile();
			break;// 上传文件
		case GETFILE:
			getFile();
			break;// 下载文件
		case DATETIME:
			dateTime();
			break;// 请求服务器时间
		case SENDMESSAGE:
			sendMessage();
			break;// 发送信息，扩展接口
		case SAVEPAGE:
			savePage();
			break;// 保存全文批注格式文件
		case LOADPAGE:
			loadPage();
			break; // 加载全文批注格式文件
		}

	}

	/**
         * 
         */
	private void loadPage() {
		mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档编号
		MsgObj.MsgTextClear(); // 清除文本信息
		mFilePath = mFilePath + "\\Document\\" + mRecordId + ".pgf"; // 全文批注文件的完整路径
		if (MsgObj.MsgFileLoad(mFilePath)) { // 调入文档内容
			MsgObj.SetMsgByName("STATUS", "打开全文批注成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("打开全文批注失败!"); // 设置错误信息
		}

	}

	/**
         * 
         */
	private void savePage() {
		mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档编号
		MsgObj.MsgTextClear(); // 清除文本信息
		mFilePath = mFilePath + "\\Document\\" + mRecordId + ".pgf"; // 全文批注文件的完整路径
		if (MsgObj.MsgFileSave(mFilePath)) { // 保存全文批注文件
			MsgObj.SetMsgByName("STATUS", "保存全文批注成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("保存全文批注失败!"); // 设置错误信息
		}

	}

	/**
         * 
         */
	private void sendMessage() {
		mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档编号
		mFileName = MsgObj.GetMsgByName("FILENAME"); // 取得文档名称
		mFileType = MsgObj.GetMsgByName("FILETYPE"); // 取得文档类型
		mCommand = MsgObj.GetMsgByName("COMMAND"); // 取得自定义的操作类型
		mContent = MsgObj.GetMsgByName("CONTENT"); // 取得文本信息 Content
		mOfficePrints = MsgObj.GetMsgByName("OFFICEPRINTS"); // 取得Office文档的打印次数
		mInfo = MsgObj.GetMsgByName("TESTINFO"); // 取得客户端传来的自定义信息
		MsgObj.MsgTextClear();
		MsgObj.MsgFileClear();
		System.out.println("COMMAND:" + mCommand);
		if (mCommand.equalsIgnoreCase("INPORTTEXT")) { // 导入文本内容功能
			if (LoadContent()) {
				MsgObj.SetMsgByName("CONTENT", mContent);
				MsgObj.SetMsgByName("STATUS", "导入成功!"); // 设置状态信息
				MsgObj.MsgError(""); // 清除错误信息
			} else {
				MsgObj.MsgError("导入失败!"); // 设置错误信息
			}
		} else if (mCommand.equalsIgnoreCase("EXPORTTEXT")) { // 导出文本内容功能
			if (SaveContent()) {
				MsgObj.SetMsgByName("STATUS", "导出成功!"); // 设置状态信息
				MsgObj.MsgError(""); // 清除错误信息
			} else {
				MsgObj.MsgError("导出失败!"); // 设置错误信
			}
		} else if (mCommand.equalsIgnoreCase("WORDTABLE")) { // 插入远程表格功能
			if (GetWordTable()) {
				MsgObj.SetMsgByName("COLUMNS", String.valueOf(mColumns)); // 列
				MsgObj.SetMsgByName("CELLS", String.valueOf(mCells)); // 行
				MsgObj.SetMsgByName("WORDCONTENT", mTableContent); // 表格内容
				MsgObj.SetMsgByName("STATUS", "增加和填充成功成功!"); // 设置状态信息
				MsgObj.MsgError(""); // 清除错误信息
			} else {
				MsgObj.MsgError("增加表格行失败!"); // 设置错误信息
			}
		} else if (mCommand.equalsIgnoreCase("COPIES")) { // 打印份数控制功能
			System.out.println("PRINTS:" + mOfficePrints);
			mCopies = Integer.parseInt(mOfficePrints); // 获得客户需要打印的份数
			if (mCopies <= 2) { // 比较打印份数，拟定该文档允许打印的总数为2份，注：可以在数据库中设置好文档允许打印的份数
				if (UpdataCopies(2 - mCopies)) { // 更新打印份数
					MsgObj.SetMsgByName("STATUS", "1"); // 设置状态信息，允许打印
					MsgObj.MsgError(""); // 清除错误信息
				}
			} else {
				MsgObj.SetMsgByName("STATUS", "0"); // 不允许打印
				MsgObj.MsgError("超过打印限度不允许打印!"); // 设置错误信息
			}
		} else if (mCommand.equalsIgnoreCase("SELFINFO")) {
			mInfo = "服务器端收到客户端传来的信息：“" + mInfo + "” | ";
			// mInfo = mInfo + "当前服务器时间：" + DbaObj.GetDateTime(); //组合返回给客户端的信息
			MsgObj.SetMsgByName("RETURNINFO", mInfo); // 将返回的信息设置到信息包中
		} else {
			MsgObj.MsgError("客户端Web发送数据包命令没有合适的处理函数![" + mCommand + "]");
			MsgObj.MsgTextClear();
			MsgObj.MsgFileClear();
		}

	}

	/**
         * 
         */
	private void dateTime() {
		// 标准日期格式字串，如 2005-8-16 10:20:35
		MsgObj.MsgTextClear(); // 清除文本信息
		// MsgObj.SetMsgByName("DATETIME", DbaObj.GetDateTime());

	}

	/**
         * 
         */
	private void getFile() {
		mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档编号
		mLocalFile = MsgObj.GetMsgByName("LOCALFILE"); // 取得本地文件名称
		mRemoteFile = MsgObj.GetMsgByName("REMOTEFILE"); // 取得远程文件名称
		MsgObj.MsgTextClear(); // 清除文本信息
		mFilePath = mFilePath + "\\Document\\" + mRemoteFile;
		if (MsgObj.MsgFileLoad(mFilePath)) { // 调入文档内容
			MsgObj.SetMsgByName("STATUS", "保存下载文件成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("下载文件失败!"); // 设置错误信息
		}

	}

	/**
         * 
         */
	private void putFile() {
		mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档编号
		mFileBody = MsgObj.MsgFileBody(); // 取得文档内容
		mLocalFile = MsgObj.GetMsgByName("LOCALFILE"); // 取得本地文件名称
		mRemoteFile = MsgObj.GetMsgByName("REMOTEFILE"); // 取得远程文件名称
		MsgObj.MsgTextClear(); // 清除文本信息
		mFilePath = mFilePath + "\\Document\\" + mRemoteFile;
		if (MsgObj.MsgFileSave(mFilePath)) { // 调入文档
			MsgObj.SetMsgByName("STATUS", "保存上传文件成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("上传文件失败!"); // 设置错误信息
		}

	}

	/**
         * 
         */
	private void insertImage() {
		mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档编号
		mLabelName = MsgObj.GetMsgByName("LABELNAME"); // 标签名
		mImageName = MsgObj.GetMsgByName("IMAGENAME"); // 图片名
		mFilePath = mFilePath + "\\Document\\" + mImageName; // 图片在服务器的完整路径
		mFileType = mImageName.substring(mImageName.length() - 4).toLowerCase(); // 取得文件的类型
		MsgObj.MsgTextClear();
		if (MsgObj.MsgFileLoad(mFilePath)) { // 调入图片
			MsgObj.SetMsgByName("IMAGETYPE", mFileType); // 指定图片的类型
			MsgObj.SetMsgByName("POSITION", mLabelName); // 设置插入的位置[书签对象名]
			MsgObj.SetMsgByName("STATUS", "插入图片成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("插入图片失败!"); // 设置错误信息
		}

	}

	/**
         * 
         */
	private void updateFile() {
		mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档编号
		mFileName = MsgObj.GetMsgByName("FILENAME"); // 取得文档名称
		mFileType = MsgObj.GetMsgByName("FILETYPE"); // 取得文档类型
		mUserName = mUserName; // 取得保存用户名称
		mDescript = "定稿版本"; // 版本说明
		mFileSize = MsgObj.MsgFileSize(); // 取得文档大小
		// mFileDate = DbaObj.GetDateTime(); //取得文档时间
		mFileBody = MsgObj.MsgFileBody(); // 取得文档内容
		MsgObj.MsgTextClear();
		if (SaveVersion()) { // 保存文档内容
			MsgObj.SetMsgByName("STATUS", "保存定稿版本成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("保存定稿版本失败!"); // 设置错误信息
		}
		MsgObj.MsgFileClear();

	}

	/**
	 * @throws IOException 
	 * @throws BusinessException 
	 * @throws NumberFormatException 
         * 
         */
	private void insertFile() throws NumberFormatException, BusinessException, IOException {
		mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档编号
		mFileName = MsgObj.GetMsgByName("FILENAME"); // 取得文档名称
		mFileType = MsgObj.GetMsgByName("FILETYPE"); // 取得文档类型
		MsgObj.MsgTextClear();
		if (LoadFile()) { // 调入文档
			MsgObj.MsgFileBody(mFileBody); // 将文件信息打包
			MsgObj.SetMsgByName("POSITION", "Content"); // 设置插入的位置[书签]
			MsgObj.SetMsgByName("STATUS", "插入文件成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("插入文件成功!"); // 设置错误信息
		}
	}

	/**
         * 
         */
	private void saveAsPage() {
		mHtmlName = MsgObj.GetMsgByName("HTMLNAME"); // 取得文件名称
		mDirectory = MsgObj.GetMsgByName("DIRECTORY"); // 取得目录名称
		MsgObj.MsgTextClear();
		if (mDirectory.trim().equalsIgnoreCase("")) {
			mFilePath = mFilePath + "\\HTML";
		} else {
			mFilePath = mFilePath + "\\HTML\\" + mDirectory;
		}
		MsgObj.MakeDirectory(mFilePath); // 创建路径
		if (MsgObj.MsgFileSave(mFilePath + "\\" + mHtmlName)) { // 保存HTML文件
			MsgObj.MsgError(""); // 清除错误信息
			MsgObj.SetMsgByName("STATUS", "保存批注HTML图片成功!"); // 设置状态信息
		} else {
			MsgObj.MsgError("保存批注HTML图片失败!"); // 设置错误信息
		}
		MsgObj.MsgFileClear();

	}

	/**
         * 
         */
	private void saveImage() {
		mHtmlName = MsgObj.GetMsgByName("HTMLNAME"); // 取得文件名称
		mDirectory = MsgObj.GetMsgByName("DIRECTORY"); // 取得目录名称
		MsgObj.MsgTextClear();
		if (mDirectory.trim().equalsIgnoreCase("")) {
			mFilePath = mFilePath + "\\HTMLIMAGE";
		} else {
			mFilePath = mFilePath + "\\HTMLIMAGE\\" + mDirectory;
		}
		MsgObj.MakeDirectory(mFilePath); // 创建路径
		if (MsgObj.MsgFileSave(mFilePath + "\\" + mHtmlName)) { // 保存HTML文件
			MsgObj.MsgError(""); // 清除错误信息
			MsgObj.SetMsgByName("STATUS", "保存HTML图片成功!"); // 设置状态信息
		} else {
			MsgObj.MsgError("保存HTML图片失败!"); // 设置错误信息
		}
		MsgObj.MsgFileClear();

	}

	/**
         * 
         */
	private void saveAsHtml() {
		mHtmlName = MsgObj.GetMsgByName("HTMLNAME"); // 取得文件名称
		mDirectory = MsgObj.GetMsgByName("DIRECTORY"); // 取得目录名称
		MsgObj.MsgTextClear();
		if (mDirectory.trim().equalsIgnoreCase("")) {
			mFilePath = mFilePath + "\\HTML";
		} else {
			mFilePath = mFilePath + "\\HTML\\" + mDirectory;
		}
		MsgObj.MakeDirectory(mFilePath); // 创建路径
		if (MsgObj.MsgFileSave(mFilePath + "\\" + mHtmlName)) { // 保存HTML文件
			MsgObj.MsgError(""); // 清除错误信息
			MsgObj.SetMsgByName("STATUS", "保存HTML成功!"); // 设置状态信息
		} else {
			MsgObj.MsgError("保存HTML失败!"); // 设置错误信息
		}
		MsgObj.MsgFileClear();

	}

	/**
         * 
         */
	private void savePdf() {
		mRecordId = MsgObj.GetMsgByName("RECORDID"); // 取得文档编号
		mFileName = MsgObj.GetMsgByName("FILENAME"); // 取得文档名称
		MsgObj.MsgTextClear(); // 清除文本信息
		if (MsgObj.MsgFileSave(mFilePath + "\\Document\\" + mRecordId + ".pdf")) { // 保存文档到文件夹中
			MsgObj.SetMsgByName("STATUS", "保存成功!"); // 设置状态信息
			MsgObj.MsgError(""); // 清除错误信息
		} else {
			MsgObj.MsgError("保存失败!"); // 设置错误信息
		}
		MsgObj.MsgFileClear();

	}

	public enum WebofficeOptions {
		LOADFILE, // 加载文件
		SAVEFILE, // 保存文件
		LOADTEMPLATE, // 加载模板
		SAVETEMPLATE, // 保存模板
		LISTVERSION, // 列出所有版本
		LOADVERSION, // 加载版本
		SAVEVERSION, // 保存版本
		LOADBOOKMARKS, // 加载书签
		SAVEBOOKMARKS, // 保存书签
		LISTBOOKMARKS, // 列出书签
		LOADMARKLIST, // 加载签名列表
		LOADMARKIMAGE, // 加载签名图片
		SAVESIGNATURE, // 保存签名
		LOADSIGNATURE, // 加载签名
		SAVEPDF, // 保存pdf
		SAVEASHTML, // 保存为html
		SAVEIMAGE, // 保存图片
		SAVEASPAGE, // 保存空格
		INSERTFILE, // 插入文件
		UPDATEFILE, // 更新文件
		INSERTIMAGE, // 插入图片
		PUTFILE, // 上传文件
		GETFILE, // 下载文件
		DATETIME, // 请求服务器时间
		SENDMESSAGE, // 发送信息，扩展接口
		SAVEPAGE, // 保存全文批注格式文件
		LOADPAGE
		// 加载全文批注格式文件
	}
}
